package Game;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.util.HashMap;
import java.util.Map;
import java.util.Properties;

public class TableValeurs {
	final private int DEPLACEMENT = 0;
	final private int UNIT_DAMAGE = 1;
	final private int TERRAIN_DAMAGE = 2;

	private HashMap<Integer, Map<Integer, Double>> _terrainDamage;
	private HashMap<Integer, Map<Integer, Double>> _uniteDamage;
	private HashMap<Integer, Map<Integer, Double>> _deplacement;
	private HashMap<String, Double> _action;

	/**
	 * Constructeur pour importer les settings à la création d'une partie 
	 */
	public TableValeurs() {
		System.out
				.println("Création Table des valeurs avec chargement des propriétés ");
		_terrainDamage = new HashMap<Integer, Map<Integer, Double>>();
		_uniteDamage = new HashMap<Integer, Map<Integer, Double>>();
		_deplacement = new HashMap<Integer, Map<Integer, Double>>();
		_action = new HashMap<String, Double>();

		FileInputStream in;
		Properties defaultProps = new Properties();
		Properties depProps = new Properties();

		try {
			in = new FileInputStream("settings.txt");
			defaultProps.load(in);
			in.close();
			in = new FileInputStream("deplacement.txt");
			depProps.load(in);
			in.close();
		} catch (FileNotFoundException e2) {
			e2.printStackTrace();
		} catch (IOException e3) {
			e3.printStackTrace();
		}

		for (Object prop : defaultProps.keySet()) {
			String stringProperties = prop.toString();

			int[] cles = { Integer.parseInt(stringProperties.substring(0, 1)),
					Integer.parseInt(stringProperties.substring(2, 3)),
					Integer.parseInt(stringProperties.substring(4, 5)) };

			double value = Double
					.parseDouble(defaultProps.get(prop).toString());

			switch (cles[0]) {
			case TERRAIN_DAMAGE:
				insertInMap(_terrainDamage, cles, value);
				break;
			case UNIT_DAMAGE:
				insertInMap(_uniteDamage, cles, value);
				break;
			case DEPLACEMENT:
				insertInMap(_deplacement, cles, value);
				break;
			}
		}

		for (Object prop : depProps.keySet()) {
			double value = Double.parseDouble(depProps.get(prop).toString());
			_action.put(prop.toString(), value);
		}
	}

	/**
	 * @param map
	 * @param cles
	 * @param value
	 */
	void insertInMap(HashMap<Integer, Map<Integer, Double>> map, int cles[],
			double value) {
		if (map.get(cles[1]) == null)
			map.put(cles[1], new HashMap<Integer, Double>());

		map.get(cles[1]).put(cles[2], value);
	}

	/**
	 * @param unitId
	 * @param terrainId
	 * @return Ratio de d�placement sur un terrain
	 */
	public Double getDeplacement(int unitId, int terrainId) {
		if (_deplacement.get(unitId) != null)
			if (_deplacement.get(unitId).get(terrainId) != null)
				return _deplacement.get(unitId).get(terrainId);
		return null;
	}

	/**
	 * @param unitId
	 * @param terrainId
	 * @return Le ratio de dommage qu'une unité peux infliger sur une type de terrain
	 */
	public Double getTerrainDamage(int unitId, int terrainId) {
		if (_terrainDamage.get(unitId) != null)
			if (_terrainDamage.get(unitId).get(terrainId) != null)
				return _terrainDamage.get(unitId).get(terrainId);
		return null;
	}

	/**
	 * @param unitId
	 * @param oppositeUnitId
	 * @return la ratio de dommage qu'un unité peux infliger à une autre unité
	 */
	public Double getUnitDamage(int unitId, int oppositeUnitId) {
		if (_uniteDamage.get(unitId) != null)
			if (_uniteDamage.get(unitId).get(oppositeUnitId) != null)
				return _uniteDamage.get(unitId).get(oppositeUnitId);
		return null;
	}

	/**
	 * @param s
	 * @return
	 */
	public Double getActionPoint(String s) {
		return _action.get(s);
	}
}
